<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE FlexibleInstances, Safe #-}</span><span>
</span><span id="line-2"></span><span>
</span><span id="line-3"></span><span class="hs-comment">-- | Monadic front-end to Text.PrettyPrint</span><span>
</span><span id="line-4"></span><span>
</span><span id="line-5"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Language.Haskell.TH.PprLib</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-6"></span><span>
</span><span id="line-7"></span><span>        </span><span class="annot"><span class="hs-comment">-- * The document type</span></span><span>
</span><span id="line-8"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier">Doc</span></a></span><span class="hs-special">,</span><span>            </span><span class="hs-comment">-- Abstract, instance of Show</span><span>
</span><span id="line-9"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#PprM"><span class="hs-identifier">PprM</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-10"></span><span>
</span><span id="line-11"></span><span>        </span><span class="annot"><span class="hs-comment">-- * Primitive Documents</span></span><span>
</span><span id="line-12"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#empty"><span class="hs-identifier">empty</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-13"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#semi"><span class="hs-identifier">semi</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#comma"><span class="hs-identifier">comma</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#colon"><span class="hs-identifier">colon</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#dcolon"><span class="hs-identifier">dcolon</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#space"><span class="hs-identifier">space</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#equals"><span class="hs-identifier">equals</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#arrow"><span class="hs-identifier">arrow</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-14"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#lparen"><span class="hs-identifier">lparen</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#rparen"><span class="hs-identifier">rparen</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#lbrack"><span class="hs-identifier">lbrack</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#rbrack"><span class="hs-identifier">rbrack</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#lbrace"><span class="hs-identifier">lbrace</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#rbrace"><span class="hs-identifier">rbrace</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-15"></span><span>
</span><span id="line-16"></span><span>        </span><span class="annot"><span class="hs-comment">-- * Converting values into documents</span></span><span>
</span><span id="line-17"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#text"><span class="hs-identifier">text</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#char"><span class="hs-identifier">char</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#ptext"><span class="hs-identifier">ptext</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-18"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#int"><span class="hs-identifier">int</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#integer"><span class="hs-identifier">integer</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#float"><span class="hs-identifier">float</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#double"><span class="hs-identifier">double</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#rational"><span class="hs-identifier">rational</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-19"></span><span>
</span><span id="line-20"></span><span>        </span><span class="annot"><span class="hs-comment">-- * Wrapping documents in delimiters</span></span><span>
</span><span id="line-21"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#parens"><span class="hs-identifier">parens</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#brackets"><span class="hs-identifier">brackets</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#braces"><span class="hs-identifier">braces</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#quotes"><span class="hs-identifier">quotes</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#doubleQuotes"><span class="hs-identifier">doubleQuotes</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-22"></span><span>
</span><span id="line-23"></span><span>        </span><span class="annot"><span class="hs-comment">-- * Combining documents</span></span><span>
</span><span id="line-24"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%3C%3E"><span class="hs-operator">(&lt;&gt;)</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%3C%2B%3E"><span class="hs-operator">(&lt;+&gt;)</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#hcat"><span class="hs-identifier">hcat</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#hsep"><span class="hs-identifier">hsep</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-25"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%24%24"><span class="hs-operator">($$)</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%24%2B%24"><span class="hs-operator">($+$)</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#vcat"><span class="hs-identifier">vcat</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-26"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#sep"><span class="hs-identifier">sep</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#cat"><span class="hs-identifier">cat</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-27"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#fsep"><span class="hs-identifier">fsep</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#fcat"><span class="hs-identifier">fcat</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-28"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#nest"><span class="hs-identifier">nest</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-29"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#hang"><span class="hs-identifier">hang</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#punctuate"><span class="hs-identifier">punctuate</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-30"></span><span>
</span><span id="line-31"></span><span>        </span><span class="annot"><span class="hs-comment">-- * Predicates on documents</span></span><span>
</span><span id="line-32"></span><span>        </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#isEmpty"><span class="hs-identifier">isEmpty</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-33"></span><span>
</span><span id="line-34"></span><span>    </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#to_HPJ_Doc"><span class="hs-identifier">to_HPJ_Doc</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#pprName"><span class="hs-identifier">pprName</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#pprName%27"><span class="hs-identifier">pprName'</span></a></span><span>
</span><span id="line-35"></span><span>  </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-36"></span><span>
</span><span id="line-37"></span><span>
</span><span id="line-38"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html"><span class="hs-identifier">Language.Haskell.TH.Syntax</span></a></span><span>
</span><span id="line-39"></span><span>    </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Uniq"><span class="hs-identifier">Uniq</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier">Name</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#showName%27"><span class="hs-identifier">showName'</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#NameFlavour"><span class="hs-identifier">NameFlavour</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#NameIs"><span class="hs-identifier">NameIs</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-40"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="../../pretty/src/Text.PrettyPrint.html#"><span class="hs-identifier">Text.PrettyPrint</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">HPJ</span></span><span>
</span><span id="line-41"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.html#"><span class="hs-identifier">Control.Monad</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier">liftM</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#liftM2"><span class="hs-identifier">liftM2</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#ap"><span class="hs-identifier">ap</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-42"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Map.html"><span class="hs-identifier">Language.Haskell.TH.Lib.Map</span></a></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Map.html#Map"><span class="hs-identifier">Map</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-43"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Map.html"><span class="hs-identifier">Language.Haskell.TH.Lib.Map</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">Map</span></span><span> </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Map.html#lookup"><span class="hs-identifier">lookup</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Map.html#insert"><span class="hs-identifier">insert</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Lib.Map.html#empty"><span class="hs-identifier">empty</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-44"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Prelude.html#"><span class="hs-identifier">Prelude</span></a></span><span> </span><span class="hs-keyword">hiding</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Base.html#%3C%3E"><span class="hs-operator">(&lt;&gt;)</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-45"></span><span>
</span><span id="line-46"></span><span class="hs-keyword">infixl</span><span> </span><span class="hs-number">6</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%3C%3E"><span class="hs-operator hs-type">&lt;&gt;</span></a></span><span>
</span><span id="line-47"></span><span class="hs-keyword">infixl</span><span> </span><span class="hs-number">6</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%3C%2B%3E"><span class="hs-operator hs-type">&lt;+&gt;</span></a></span><span>
</span><span id="line-48"></span><span class="hs-keyword">infixl</span><span> </span><span class="hs-number">5</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%24%24"><span class="hs-operator hs-type">$$</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%24%2B%24"><span class="hs-operator hs-type">$+$</span></a></span><span>
</span><span id="line-49"></span><span>
</span><span id="line-50"></span><span class="hs-comment">-- ---------------------------------------------------------------------------</span><span>
</span><span id="line-51"></span><span class="hs-comment">-- The interface</span><span>
</span><span id="line-52"></span><span>
</span><span id="line-53"></span><span class="hs-comment">-- The primitive Doc values</span><span>
</span><span id="line-54"></span><span>
</span><span id="line-55"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679163177"><span id="local-6989586621679163180"><span class="annot"><a href="../../base/src/GHC.Show.html#Show"><span class="hs-identifier hs-type">Show</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-56"></span><span>   </span><span id="local-6989586621679163175"><span class="annot"><span class="annottext">show :: Doc -&gt; String
</span><a href="../../base/src/GHC.Show.html#show"><span class="hs-identifier hs-var hs-var hs-var hs-var">show</span></a></span></span><span> </span><span id="local-6989586621679163173"><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163173"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; String
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#render"><span class="hs-identifier hs-var">HPJ.render</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#to_HPJ_Doc"><span class="hs-identifier hs-var">to_HPJ_Doc</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163173"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-57"></span><span>
</span><span id="line-58"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#isEmpty"><span class="hs-identifier hs-type">isEmpty</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#PprM"><span class="hs-identifier hs-type">PprM</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span><span class="hs-special">;</span><span>  </span><span class="hs-comment">-- ^ Returns 'True' if the document is empty</span><span>
</span><span id="line-59"></span><span>
</span><span id="line-60"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#empty"><span class="hs-identifier hs-type">empty</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ An empty document</span><span>
</span><span id="line-61"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#semi"><span class="hs-identifier hs-type">semi</span></a></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A ';' character</span><span>
</span><span id="line-62"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#comma"><span class="hs-identifier hs-type">comma</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A ',' character</span><span>
</span><span id="line-63"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#colon"><span class="hs-identifier hs-type">colon</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A ':' character</span><span>
</span><span id="line-64"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#dcolon"><span class="hs-identifier hs-type">dcolon</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A &quot;::&quot; string</span><span>
</span><span id="line-65"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#space"><span class="hs-identifier hs-type">space</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A space character</span><span>
</span><span id="line-66"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#equals"><span class="hs-identifier hs-type">equals</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A '=' character</span><span>
</span><span id="line-67"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#arrow"><span class="hs-identifier hs-type">arrow</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A &quot;-&gt;&quot; string</span><span>
</span><span id="line-68"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#lparen"><span class="hs-identifier hs-type">lparen</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A '(' character</span><span>
</span><span id="line-69"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#rparen"><span class="hs-identifier hs-type">rparen</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A ')' character</span><span>
</span><span id="line-70"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#lbrack"><span class="hs-identifier hs-type">lbrack</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A '[' character</span><span>
</span><span id="line-71"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#rbrack"><span class="hs-identifier hs-type">rbrack</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A ']' character</span><span>
</span><span id="line-72"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#lbrace"><span class="hs-identifier hs-type">lbrace</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A '{' character</span><span>
</span><span id="line-73"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#rbrace"><span class="hs-identifier hs-type">rbrace</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>                 </span><span class="hs-comment">-- ^ A '}' character</span><span>
</span><span id="line-74"></span><span>
</span><span id="line-75"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#text"><span class="hs-identifier hs-type">text</span></a></span><span>     </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>   </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span>
</span><span id="line-76"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#ptext"><span class="hs-identifier hs-type">ptext</span></a></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>   </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span>
</span><span id="line-77"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#char"><span class="hs-identifier hs-type">char</span></a></span><span>     </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Char"><span class="hs-identifier hs-type">Char</span></a></span><span>     </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span>
</span><span id="line-78"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#int"><span class="hs-identifier hs-type">int</span></a></span><span>      </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span>      </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span>
</span><span id="line-79"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#integer"><span class="hs-identifier hs-type">integer</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><span class="hs-identifier hs-type">Integer</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span>
</span><span id="line-80"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#float"><span class="hs-identifier hs-type">float</span></a></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Float"><span class="hs-identifier hs-type">Float</span></a></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span>
</span><span id="line-81"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#double"><span class="hs-identifier hs-type">double</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Double"><span class="hs-identifier hs-type">Double</span></a></span><span>   </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span>
</span><span id="line-82"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#rational"><span class="hs-identifier hs-type">rational</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../base/src/GHC.Real.html#Rational"><span class="hs-identifier hs-type">Rational</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span>
</span><span id="line-83"></span><span>
</span><span id="line-84"></span><span>
</span><span id="line-85"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#parens"><span class="hs-identifier hs-type">parens</span></a></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>     </span><span class="hs-comment">-- ^ Wrap document in @(...)@</span><span>
</span><span id="line-86"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#brackets"><span class="hs-identifier hs-type">brackets</span></a></span><span>     </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>     </span><span class="hs-comment">-- ^ Wrap document in @[...]@</span><span>
</span><span id="line-87"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#braces"><span class="hs-identifier hs-type">braces</span></a></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>     </span><span class="hs-comment">-- ^ Wrap document in @{...}@</span><span>
</span><span id="line-88"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#quotes"><span class="hs-identifier hs-type">quotes</span></a></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>     </span><span class="hs-comment">-- ^ Wrap document in @\'...\'@</span><span>
</span><span id="line-89"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#doubleQuotes"><span class="hs-identifier hs-type">doubleQuotes</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>     </span><span class="hs-comment">-- ^ Wrap document in @\&quot;...\&quot;@</span><span>
</span><span id="line-90"></span><span>
</span><span id="line-91"></span><span class="hs-comment">-- Combining @Doc@ values</span><span>
</span><span id="line-92"></span><span>
</span><span id="line-93"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%3C%3E"><span class="hs-operator hs-type">(&lt;&gt;)</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>     </span><span class="hs-comment">-- ^Beside</span><span>
</span><span id="line-94"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#hcat"><span class="hs-identifier hs-type">hcat</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>          </span><span class="hs-comment">-- ^List version of '&lt;&gt;'</span><span>
</span><span id="line-95"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%3C%2B%3E"><span class="hs-operator hs-type">(&lt;+&gt;)</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>     </span><span class="hs-comment">-- ^Beside, separated by space</span><span>
</span><span id="line-96"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#hsep"><span class="hs-identifier hs-type">hsep</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>          </span><span class="hs-comment">-- ^List version of '&lt;+&gt;'</span><span>
</span><span id="line-97"></span><span>
</span><span id="line-98"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%24%24"><span class="hs-operator hs-type">($$)</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>     </span><span class="hs-comment">-- ^Above; if there is no</span><span>
</span><span id="line-99"></span><span>                                 </span><span class="hs-comment">-- overlap it \&quot;dovetails\&quot; the two</span><span>
</span><span id="line-100"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#%24%2B%24"><span class="hs-operator hs-type">($+$)</span></a></span><span>  </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>     </span><span class="hs-comment">-- ^Above, without dovetailing.</span><span>
</span><span id="line-101"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#vcat"><span class="hs-identifier hs-type">vcat</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>          </span><span class="hs-comment">-- ^List version of '$$'</span><span>
</span><span id="line-102"></span><span>
</span><span id="line-103"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#cat"><span class="hs-identifier hs-type">cat</span></a></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>          </span><span class="hs-comment">-- ^ Either hcat or vcat</span><span>
</span><span id="line-104"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#sep"><span class="hs-identifier hs-type">sep</span></a></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>          </span><span class="hs-comment">-- ^ Either hsep or vcat</span><span>
</span><span id="line-105"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#fcat"><span class="hs-identifier hs-type">fcat</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>          </span><span class="hs-comment">-- ^ \&quot;Paragraph fill\&quot; version of cat</span><span>
</span><span id="line-106"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#fsep"><span class="hs-identifier hs-type">fsep</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>          </span><span class="hs-comment">-- ^ \&quot;Paragraph fill\&quot; version of sep</span><span>
</span><span id="line-107"></span><span>
</span><span id="line-108"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#nest"><span class="hs-identifier hs-type">nest</span></a></span><span>   </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>     </span><span class="hs-comment">-- ^ Nested</span><span>
</span><span id="line-109"></span><span>
</span><span id="line-110"></span><span>
</span><span id="line-111"></span><span class="hs-comment">-- GHC-specific ones.</span><span>
</span><span id="line-112"></span><span>
</span><span id="line-113"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#hang"><span class="hs-identifier hs-type">hang</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">;</span><span>      </span><span class="hs-comment">-- ^ @hang d1 n d2 = sep [d1, nest n d2]@</span><span>
</span><span id="line-114"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#punctuate"><span class="hs-identifier hs-type">punctuate</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">[</span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-115"></span><span>   </span><span class="hs-comment">-- ^ @punctuate p [d1, ... dn] = [d1 \&lt;&gt; p, d2 \&lt;&gt; p, ... dn-1 \&lt;&gt; p, dn]@</span><span>
</span><span id="line-116"></span><span>
</span><span id="line-117"></span><span class="hs-comment">-- ---------------------------------------------------------------------------</span><span>
</span><span id="line-118"></span><span class="hs-comment">-- The &quot;implementation&quot;</span><span>
</span><span id="line-119"></span><span>
</span><span id="line-120"></span><span class="hs-keyword">type</span><span> </span><span id="State"><span class="annot"><a href="Language.Haskell.TH.PprLib.html#State"><span class="hs-identifier hs-var">State</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Lib.Map.html#Map"><span class="hs-identifier hs-type">Map</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Uniq"><span class="hs-identifier hs-type">Uniq</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-121"></span><span class="hs-keyword">data</span><span> </span><span id="PprM"><span class="annot"><a href="Language.Haskell.TH.PprLib.html#PprM"><span class="hs-identifier hs-var">PprM</span></a></span></span><span> </span><span id="local-6989586621679163369"><span class="annot"><a href="#local-6989586621679163369"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="PprM"><span class="annot"><a href="Language.Haskell.TH.PprLib.html#PprM"><span class="hs-identifier hs-var">PprM</span></a></span></span><span> </span><span class="hs-special">{</span><span> </span><span id="runPprM"><span class="annot"><span class="annottext">forall a. PprM a -&gt; State -&gt; (a, State)
</span><a href="Language.Haskell.TH.PprLib.html#runPprM"><span class="hs-identifier hs-var hs-var">runPprM</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#State"><span class="hs-identifier hs-type">State</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679163369"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#State"><span class="hs-identifier hs-type">State</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-122"></span><span>
</span><span id="line-123"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#pprName"><span class="hs-identifier hs-type">pprName</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span>
</span><span id="line-124"></span><span id="pprName"><span class="annot"><span class="annottext">pprName :: Name -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#pprName"><span class="hs-identifier hs-var hs-var">pprName</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">NameIs -&gt; Name -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#pprName%27"><span class="hs-identifier hs-var">pprName'</span></a></span><span> </span><span class="annot"><span class="annottext">NameIs
</span><a href="Language.Haskell.TH.Syntax.html#Alone"><span class="hs-identifier hs-var">Alone</span></a></span><span>
</span><span id="line-125"></span><span>
</span><span id="line-126"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#pprName%27"><span class="hs-identifier hs-type">pprName'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#NameIs"><span class="hs-identifier hs-type">NameIs</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span>
</span><span id="line-127"></span><span id="pprName%27"><span class="annot"><span class="annottext">pprName' :: NameIs -&gt; Name -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#pprName%27"><span class="hs-identifier hs-var hs-var">pprName'</span></a></span></span><span> </span><span id="local-6989586621679163168"><span class="annot"><span class="annottext">NameIs
</span><a href="#local-6989586621679163168"><span class="hs-identifier hs-var">ni</span></a></span></span><span> </span><span id="local-6989586621679163167"><span class="annot"><span class="annottext">n :: Name
</span><a href="#local-6989586621679163167"><span class="hs-identifier hs-var">n</span></a></span></span><span class="hs-glyph">@</span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-type">Name</span></a></span><span> </span><span id="local-6989586621679163165"><span class="annot"><span class="annottext">OccName
</span><a href="#local-6989586621679163165"><span class="hs-identifier hs-var">o</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Language.Haskell.TH.Syntax.html#NameU"><span class="hs-identifier hs-type">NameU</span></a></span><span> </span><span class="annot"><span class="annottext">Uniq
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-128"></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(State -&gt; (Doc, State)) -&gt; Doc
forall a. (State -&gt; (a, State)) -&gt; PprM a
</span><a href="Language.Haskell.TH.PprLib.html#PprM"><span class="hs-identifier hs-var">PprM</span></a></span><span> </span><span class="annot"><span class="annottext">((State -&gt; (Doc, State)) -&gt; Doc) -&gt; (State -&gt; (Doc, State)) -&gt; Doc
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679163163"><span class="annot"><span class="annottext">s :: State
</span><a href="#local-6989586621679163163"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-glyph">@</span><span class="hs-special">(</span><span id="local-6989586621679163162"><span class="annot"><span class="annottext">Map Name Name
</span><a href="#local-6989586621679163162"><span class="hs-identifier hs-var">fm</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679163161"><span class="annot"><span class="annottext">Uniq
</span><a href="#local-6989586621679163161"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">)</span><span>
</span><span id="line-129"></span><span>        </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">let</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679163154"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679163154"><span class="hs-identifier hs-var">n'</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679163153"><span class="annot"><span class="annottext">State
</span><a href="#local-6989586621679163153"><span class="hs-identifier hs-var">s'</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Name -&gt; Map Name Name -&gt; Maybe Name
forall k a. Ord k =&gt; k -&gt; Map k a -&gt; Maybe a
</span><a href="Language.Haskell.TH.Lib.Map.html#lookup"><span class="hs-identifier hs-var">Map.lookup</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679163167"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Map Name Name
</span><a href="#local-6989586621679163162"><span class="hs-identifier hs-var">fm</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-130"></span><span>                         </span><span class="annot"><a href="../../base/src/GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679163152"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679163152"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679163152"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">State
</span><a href="#local-6989586621679163163"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-131"></span><span>                         </span><span class="annot"><span class="annottext">Maybe Name
</span><a href="../../base/src/GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679163151"><span class="annot"><span class="annottext">n'' :: Name
</span><a href="#local-6989586621679163151"><span class="hs-identifier hs-var hs-var">n''</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">OccName -&gt; NameFlavour -&gt; Name
</span><a href="Language.Haskell.TH.Syntax.html#Name"><span class="hs-identifier hs-var">Name</span></a></span><span> </span><span class="annot"><span class="annottext">OccName
</span><a href="#local-6989586621679163165"><span class="hs-identifier hs-var">o</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Uniq -&gt; NameFlavour
</span><a href="Language.Haskell.TH.Syntax.html#NameU"><span class="hs-identifier hs-var">NameU</span></a></span><span> </span><span class="annot"><span class="annottext">Uniq
</span><a href="#local-6989586621679163161"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-132"></span><span>                                    </span><span class="hs-keyword">in</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679163151"><span class="hs-identifier hs-var">n''</span></a></span><span class="hs-special">,</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Name -&gt; Name -&gt; Map Name Name -&gt; Map Name Name
forall k a. Ord k =&gt; k -&gt; a -&gt; Map k a -&gt; Map k a
</span><a href="Language.Haskell.TH.Lib.Map.html#insert"><span class="hs-identifier hs-var">Map.insert</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679163167"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679163151"><span class="hs-identifier hs-var">n''</span></a></span><span> </span><span class="annot"><span class="annottext">Map Name Name
</span><a href="#local-6989586621679163162"><span class="hs-identifier hs-var">fm</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Uniq
</span><a href="#local-6989586621679163161"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Uniq -&gt; Uniq -&gt; Uniq
forall a. Num a =&gt; a -&gt; a -&gt; a
</span><a href="../../base/src/GHC.Num.html#%2B"><span class="hs-operator hs-var">+</span></a></span><span> </span><span class="annot"><span class="annottext">Uniq
</span><span class="hs-number">1</span></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-133"></span><span>           </span><span class="hs-keyword">in</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#text"><span class="hs-identifier hs-var">HPJ.text</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; Doc) -&gt; String -&gt; Doc
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">NameIs -&gt; Name -&gt; String
</span><a href="Language.Haskell.TH.Syntax.html#showName%27"><span class="hs-identifier hs-var">showName'</span></a></span><span> </span><span class="annot"><span class="annottext">NameIs
</span><a href="#local-6989586621679163168"><span class="hs-identifier hs-var">ni</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679163154"><span class="hs-identifier hs-var">n'</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">State
</span><a href="#local-6989586621679163153"><span class="hs-identifier hs-var">s'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-134"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#pprName%27"><span class="hs-identifier hs-var">pprName'</span></a></span><span> </span><span id="local-6989586621679163148"><span class="annot"><span class="annottext">NameIs
</span><a href="#local-6989586621679163148"><span class="hs-identifier hs-var">ni</span></a></span></span><span> </span><span id="local-6989586621679163147"><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679163147"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#text"><span class="hs-identifier hs-var">text</span></a></span><span> </span><span class="annot"><span class="annottext">(String -&gt; Doc) -&gt; String -&gt; Doc
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">NameIs -&gt; Name -&gt; String
</span><a href="Language.Haskell.TH.Syntax.html#showName%27"><span class="hs-identifier hs-var">showName'</span></a></span><span> </span><span class="annot"><span class="annottext">NameIs
</span><a href="#local-6989586621679163148"><span class="hs-identifier hs-var">ni</span></a></span><span> </span><span class="annot"><span class="annottext">Name
</span><a href="#local-6989586621679163147"><span class="hs-identifier hs-var">n</span></a></span><span>
</span><span id="line-135"></span><span>
</span><span id="line-136"></span><span class="hs-comment">{-
instance Show Name where
  show (Name occ (NameU u))    = occString occ ++ &quot;_&quot; ++ show (I# u)
  show (Name occ NameS)        = occString occ
  show (Name occ (NameG ns m)) = modString m ++ &quot;.&quot; ++ occString occ

data Name = Name OccName NameFlavour

data NameFlavour
  | NameU Int#                  -- A unique local name
-}</span><span>
</span><span id="line-147"></span><span>
</span><span id="line-148"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#to_HPJ_Doc"><span class="hs-identifier hs-type">to_HPJ_Doc</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-type">Doc</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#Doc"><span class="hs-identifier hs-type">HPJ.Doc</span></a></span><span>
</span><span id="line-149"></span><span id="to_HPJ_Doc"><span class="annot"><span class="annottext">to_HPJ_Doc :: Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#to_HPJ_Doc"><span class="hs-identifier hs-var hs-var">to_HPJ_Doc</span></a></span></span><span> </span><span id="local-6989586621679163146"><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163146"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc, State) -&gt; Doc
forall a b. (a, b) -&gt; a
</span><a href="../../base/src/Data.Tuple.html#fst"><span class="hs-identifier hs-var">fst</span></a></span><span> </span><span class="annot"><span class="annottext">((Doc, State) -&gt; Doc) -&gt; (Doc, State) -&gt; Doc
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; State -&gt; (Doc, State)
forall a. PprM a -&gt; State -&gt; (a, State)
</span><a href="Language.Haskell.TH.PprLib.html#runPprM"><span class="hs-identifier hs-var hs-var">runPprM</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163146"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Map Name Name
forall k a. Map k a
</span><a href="Language.Haskell.TH.Lib.Map.html#empty"><span class="hs-identifier hs-var">Map.empty</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Uniq
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-150"></span><span>
</span><span id="line-151"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679163143"><span class="annot"><a href="../../base/src/GHC.Base.html#Functor"><span class="hs-identifier hs-type">Functor</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#PprM"><span class="hs-identifier hs-type">PprM</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-152"></span><span>      </span><span id="local-6989586621679163140"><span class="annot"><span class="annottext">fmap :: forall a b. (a -&gt; b) -&gt; PprM a -&gt; PprM b
</span><a href="../../base/src/GHC.Base.html#fmap"><span class="hs-identifier hs-var hs-var hs-var hs-var">fmap</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(a -&gt; b) -&gt; PprM a -&gt; PprM b
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span>
</span><span id="line-153"></span><span>
</span><span id="line-154"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679163130"><span id="local-6989586621679163132"><span id="local-6989586621679163134"><span class="annot"><a href="../../base/src/GHC.Base.html#Applicative"><span class="hs-identifier hs-type">Applicative</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#PprM"><span class="hs-identifier hs-type">PprM</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-155"></span><span>      </span><span id="local-6989586621679163128"><span class="annot"><span class="annottext">pure :: forall a. a -&gt; PprM a
</span><a href="../../base/src/GHC.Base.html#pure"><span class="hs-identifier hs-var hs-var hs-var hs-var">pure</span></a></span></span><span> </span><span id="local-6989586621679163127"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679163127"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(State -&gt; (a, State)) -&gt; PprM a
forall a. (State -&gt; (a, State)) -&gt; PprM a
</span><a href="Language.Haskell.TH.PprLib.html#PprM"><span class="hs-identifier hs-var">PprM</span></a></span><span> </span><span class="annot"><span class="annottext">((State -&gt; (a, State)) -&gt; PprM a)
-&gt; (State -&gt; (a, State)) -&gt; PprM a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679163126"><span class="annot"><span class="annottext">State
</span><a href="#local-6989586621679163126"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679163127"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">State
</span><a href="#local-6989586621679163126"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-156"></span><span>      </span><span id="local-6989586621679163124"><span class="annot"><span class="annottext">&lt;*&gt; :: forall a b. PprM (a -&gt; b) -&gt; PprM a -&gt; PprM b
</span><a href="../../base/src/GHC.Base.html#%3C%2A%3E"><span class="hs-operator hs-var hs-var hs-var hs-var">(&lt;*&gt;)</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PprM (a -&gt; b) -&gt; PprM a -&gt; PprM b
forall (m :: * -&gt; *) a b. Monad m =&gt; m (a -&gt; b) -&gt; m a -&gt; m b
</span><a href="../../base/src/GHC.Base.html#ap"><span class="hs-identifier hs-var">ap</span></a></span><span>
</span><span id="line-157"></span><span>
</span><span id="line-158"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679163117"><span id="local-6989586621679163119"><span class="annot"><a href="../../base/src/GHC.Base.html#Monad"><span class="hs-identifier hs-type">Monad</span></a></span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#PprM"><span class="hs-identifier hs-type">PprM</span></a></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-159"></span><span>    </span><span id="local-6989586621679163115"><span class="annot"><span class="annottext">PprM a
</span><a href="#local-6989586621679163115"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span id="local-6989586621679163114"><span class="annot"><span class="annottext">&gt;&gt;= :: forall a b. PprM a -&gt; (a -&gt; PprM b) -&gt; PprM b
</span><a href="../../base/src/GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var hs-var hs-var hs-var">&gt;&gt;=</span></a></span></span><span> </span><span id="local-6989586621679163113"><span class="annot"><span class="annottext">a -&gt; PprM b
</span><a href="#local-6989586621679163113"><span class="hs-identifier hs-var">k</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(State -&gt; (b, State)) -&gt; PprM b
forall a. (State -&gt; (a, State)) -&gt; PprM a
</span><a href="Language.Haskell.TH.PprLib.html#PprM"><span class="hs-identifier hs-var">PprM</span></a></span><span> </span><span class="annot"><span class="annottext">((State -&gt; (b, State)) -&gt; PprM b)
-&gt; (State -&gt; (b, State)) -&gt; PprM b
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679163112"><span class="annot"><span class="annottext">State
</span><a href="#local-6989586621679163112"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">let</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679163111"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679163111"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679163110"><span class="annot"><span class="annottext">State
</span><a href="#local-6989586621679163110"><span class="hs-identifier hs-var">s'</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">PprM a -&gt; State -&gt; (a, State)
forall a. PprM a -&gt; State -&gt; (a, State)
</span><a href="Language.Haskell.TH.PprLib.html#runPprM"><span class="hs-identifier hs-var hs-var">runPprM</span></a></span><span> </span><span class="annot"><span class="annottext">PprM a
</span><a href="#local-6989586621679163115"><span class="hs-identifier hs-var">m</span></a></span><span> </span><span class="annot"><span class="annottext">State
</span><a href="#local-6989586621679163112"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-160"></span><span>                            </span><span class="hs-keyword">in</span><span> </span><span class="annot"><span class="annottext">PprM b -&gt; State -&gt; (b, State)
forall a. PprM a -&gt; State -&gt; (a, State)
</span><a href="Language.Haskell.TH.PprLib.html#runPprM"><span class="hs-identifier hs-var hs-var">runPprM</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; PprM b
</span><a href="#local-6989586621679163113"><span class="hs-identifier hs-var">k</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679163111"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">State
</span><a href="#local-6989586621679163110"><span class="hs-identifier hs-var">s'</span></a></span><span>
</span><span id="line-161"></span><span>
</span><span id="line-162"></span><span class="hs-keyword">type</span><span> </span><span id="Doc"><span class="annot"><a href="Language.Haskell.TH.PprLib.html#Doc"><span class="hs-identifier hs-var">Doc</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#PprM"><span class="hs-identifier hs-type">PprM</span></a></span><span> </span><span class="annot"><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#Doc"><span class="hs-identifier hs-type">HPJ.Doc</span></a></span><span>
</span><span id="line-163"></span><span>
</span><span id="line-164"></span><span class="hs-comment">-- The primitive Doc values</span><span>
</span><span id="line-165"></span><span>
</span><span id="line-166"></span><span id="isEmpty"><span class="annot"><span class="annottext">isEmpty :: Doc -&gt; PprM Bool
</span><a href="Language.Haskell.TH.PprLib.html#isEmpty"><span class="hs-identifier hs-var hs-var">isEmpty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Bool) -&gt; Doc -&gt; PprM Bool
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Bool
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#isEmpty"><span class="hs-identifier hs-var">HPJ.isEmpty</span></a></span><span>
</span><span id="line-167"></span><span>
</span><span id="line-168"></span><span id="empty"><span class="annot"><span class="annottext">empty :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#empty"><span class="hs-identifier hs-var hs-var">empty</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#empty"><span class="hs-identifier hs-var">HPJ.empty</span></a></span><span>
</span><span id="line-169"></span><span id="semi"><span class="annot"><span class="annottext">semi :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#semi"><span class="hs-identifier hs-var hs-var">semi</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#semi"><span class="hs-identifier hs-var">HPJ.semi</span></a></span><span>
</span><span id="line-170"></span><span id="comma"><span class="annot"><span class="annottext">comma :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#comma"><span class="hs-identifier hs-var hs-var">comma</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#comma"><span class="hs-identifier hs-var">HPJ.comma</span></a></span><span>
</span><span id="line-171"></span><span id="colon"><span class="annot"><span class="annottext">colon :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#colon"><span class="hs-identifier hs-var hs-var">colon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#colon"><span class="hs-identifier hs-var">HPJ.colon</span></a></span><span>
</span><span id="line-172"></span><span id="dcolon"><span class="annot"><span class="annottext">dcolon :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#dcolon"><span class="hs-identifier hs-var hs-var">dcolon</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; Doc -&gt; Doc
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#text"><span class="hs-identifier hs-var">HPJ.text</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;::&quot;</span></span><span>
</span><span id="line-173"></span><span id="space"><span class="annot"><span class="annottext">space :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#space"><span class="hs-identifier hs-var hs-var">space</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#space"><span class="hs-identifier hs-var">HPJ.space</span></a></span><span>
</span><span id="line-174"></span><span id="equals"><span class="annot"><span class="annottext">equals :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#equals"><span class="hs-identifier hs-var hs-var">equals</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#equals"><span class="hs-identifier hs-var">HPJ.equals</span></a></span><span>
</span><span id="line-175"></span><span id="arrow"><span class="annot"><span class="annottext">arrow :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#arrow"><span class="hs-identifier hs-var hs-var">arrow</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; Doc -&gt; Doc
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#text"><span class="hs-identifier hs-var">HPJ.text</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;-&gt;&quot;</span></span><span>
</span><span id="line-176"></span><span id="lparen"><span class="annot"><span class="annottext">lparen :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#lparen"><span class="hs-identifier hs-var hs-var">lparen</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#lparen"><span class="hs-identifier hs-var">HPJ.lparen</span></a></span><span>
</span><span id="line-177"></span><span id="rparen"><span class="annot"><span class="annottext">rparen :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#rparen"><span class="hs-identifier hs-var hs-var">rparen</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#rparen"><span class="hs-identifier hs-var">HPJ.rparen</span></a></span><span>
</span><span id="line-178"></span><span id="lbrack"><span class="annot"><span class="annottext">lbrack :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#lbrack"><span class="hs-identifier hs-var hs-var">lbrack</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#lbrack"><span class="hs-identifier hs-var">HPJ.lbrack</span></a></span><span>
</span><span id="line-179"></span><span id="rbrack"><span class="annot"><span class="annottext">rbrack :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#rbrack"><span class="hs-identifier hs-var hs-var">rbrack</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#rbrack"><span class="hs-identifier hs-var">HPJ.rbrack</span></a></span><span>
</span><span id="line-180"></span><span id="lbrace"><span class="annot"><span class="annottext">lbrace :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#lbrace"><span class="hs-identifier hs-var hs-var">lbrace</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#lbrace"><span class="hs-identifier hs-var">HPJ.lbrace</span></a></span><span>
</span><span id="line-181"></span><span id="rbrace"><span class="annot"><span class="annottext">rbrace :: Doc
</span><a href="Language.Haskell.TH.PprLib.html#rbrace"><span class="hs-identifier hs-var hs-var">rbrace</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#rbrace"><span class="hs-identifier hs-var">HPJ.rbrace</span></a></span><span>
</span><span id="line-182"></span><span>
</span><span id="line-183"></span><span id="text"><span class="annot"><span class="annottext">text :: String -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#text"><span class="hs-identifier hs-var hs-var">text</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; (String -&gt; Doc) -&gt; String -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#text"><span class="hs-identifier hs-var">HPJ.text</span></a></span><span>
</span><span id="line-184"></span><span id="ptext"><span class="annot"><span class="annottext">ptext :: String -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#ptext"><span class="hs-identifier hs-var hs-var">ptext</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; (String -&gt; Doc) -&gt; String -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#ptext"><span class="hs-identifier hs-var">HPJ.ptext</span></a></span><span>
</span><span id="line-185"></span><span id="char"><span class="annot"><span class="annottext">char :: Char -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#char"><span class="hs-identifier hs-var hs-var">char</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; (Char -&gt; Doc) -&gt; Char -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#char"><span class="hs-identifier hs-var">HPJ.char</span></a></span><span>
</span><span id="line-186"></span><span id="int"><span class="annot"><span class="annottext">int :: Int -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#int"><span class="hs-identifier hs-var hs-var">int</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; (Int -&gt; Doc) -&gt; Int -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#int"><span class="hs-identifier hs-var">HPJ.int</span></a></span><span>
</span><span id="line-187"></span><span id="integer"><span class="annot"><span class="annottext">integer :: Uniq -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#integer"><span class="hs-identifier hs-var hs-var">integer</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; (Uniq -&gt; Doc) -&gt; Uniq -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Uniq -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#integer"><span class="hs-identifier hs-var">HPJ.integer</span></a></span><span>
</span><span id="line-188"></span><span id="float"><span class="annot"><span class="annottext">float :: Float -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#float"><span class="hs-identifier hs-var hs-var">float</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; (Float -&gt; Doc) -&gt; Float -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Float -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#float"><span class="hs-identifier hs-var">HPJ.float</span></a></span><span>
</span><span id="line-189"></span><span id="double"><span class="annot"><span class="annottext">double :: Double -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#double"><span class="hs-identifier hs-var hs-var">double</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; (Double -&gt; Doc) -&gt; Double -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Double -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#double"><span class="hs-identifier hs-var">HPJ.double</span></a></span><span>
</span><span id="line-190"></span><span id="rational"><span class="annot"><span class="annottext">rational :: Rational -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#rational"><span class="hs-identifier hs-var hs-var">rational</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; (Rational -&gt; Doc) -&gt; Rational -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Rational -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#rational"><span class="hs-identifier hs-var">HPJ.rational</span></a></span><span>
</span><span id="line-191"></span><span>
</span><span id="line-192"></span><span>
</span><span id="line-193"></span><span id="parens"><span class="annot"><span class="annottext">parens :: Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#parens"><span class="hs-identifier hs-var hs-var">parens</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; Doc -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#parens"><span class="hs-identifier hs-var">HPJ.parens</span></a></span><span>
</span><span id="line-194"></span><span id="brackets"><span class="annot"><span class="annottext">brackets :: Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#brackets"><span class="hs-identifier hs-var hs-var">brackets</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; Doc -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#brackets"><span class="hs-identifier hs-var">HPJ.brackets</span></a></span><span>
</span><span id="line-195"></span><span id="braces"><span class="annot"><span class="annottext">braces :: Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#braces"><span class="hs-identifier hs-var hs-var">braces</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; Doc -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#braces"><span class="hs-identifier hs-var">HPJ.braces</span></a></span><span>
</span><span id="line-196"></span><span id="quotes"><span class="annot"><span class="annottext">quotes :: Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#quotes"><span class="hs-identifier hs-var hs-var">quotes</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; Doc -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#quotes"><span class="hs-identifier hs-var">HPJ.quotes</span></a></span><span>
</span><span id="line-197"></span><span id="doubleQuotes"><span class="annot"><span class="annottext">doubleQuotes :: Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#doubleQuotes"><span class="hs-identifier hs-var hs-var">doubleQuotes</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; Doc -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#doubleQuotes"><span class="hs-identifier hs-var">HPJ.doubleQuotes</span></a></span><span>
</span><span id="line-198"></span><span>
</span><span id="line-199"></span><span class="hs-comment">-- Combining @Doc@ values</span><span>
</span><span id="line-200"></span><span>
</span><span id="line-201"></span><span id="%3C%3E"><span class="annot"><span class="annottext">&lt;&gt; :: Doc -&gt; Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#%3C%3E"><span class="hs-operator hs-var hs-var">(&lt;&gt;)</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc -&gt; Doc) -&gt; Doc -&gt; Doc -&gt; Doc
forall (m :: * -&gt; *) a1 a2 r.
Monad m =&gt;
(a1 -&gt; a2 -&gt; r) -&gt; m a1 -&gt; m a2 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM2"><span class="hs-identifier hs-var">liftM2</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#%3C%3E"><span class="hs-operator hs-var">(HPJ.&lt;&gt;)</span></a></span><span>
</span><span id="line-202"></span><span id="hcat"><span class="annot"><span class="annottext">hcat :: [Doc] -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#hcat"><span class="hs-identifier hs-var hs-var">hcat</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([Doc] -&gt; Doc) -&gt; PprM [Doc] -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#hcat"><span class="hs-identifier hs-var">HPJ.hcat</span></a></span><span> </span><span class="annot"><span class="annottext">(PprM [Doc] -&gt; Doc) -&gt; ([Doc] -&gt; PprM [Doc]) -&gt; [Doc] -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; PprM [Doc]
forall (t :: * -&gt; *) (m :: * -&gt; *) a.
(Traversable t, Monad m) =&gt;
t (m a) -&gt; m (t a)
</span><a href="../../base/src/Data.Traversable.html#sequence"><span class="hs-identifier hs-var">sequence</span></a></span><span>
</span><span id="line-203"></span><span id="%3C%2B%3E"><span class="annot"><span class="annottext">&lt;+&gt; :: Doc -&gt; Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#%3C%2B%3E"><span class="hs-operator hs-var hs-var">(&lt;+&gt;)</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc -&gt; Doc) -&gt; Doc -&gt; Doc -&gt; Doc
forall (m :: * -&gt; *) a1 a2 r.
Monad m =&gt;
(a1 -&gt; a2 -&gt; r) -&gt; m a1 -&gt; m a2 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM2"><span class="hs-identifier hs-var">liftM2</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#%3C%2B%3E"><span class="hs-operator hs-var">(HPJ.&lt;+&gt;)</span></a></span><span>
</span><span id="line-204"></span><span id="hsep"><span class="annot"><span class="annottext">hsep :: [Doc] -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#hsep"><span class="hs-identifier hs-var hs-var">hsep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([Doc] -&gt; Doc) -&gt; PprM [Doc] -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#hsep"><span class="hs-identifier hs-var">HPJ.hsep</span></a></span><span> </span><span class="annot"><span class="annottext">(PprM [Doc] -&gt; Doc) -&gt; ([Doc] -&gt; PprM [Doc]) -&gt; [Doc] -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; PprM [Doc]
forall (t :: * -&gt; *) (m :: * -&gt; *) a.
(Traversable t, Monad m) =&gt;
t (m a) -&gt; m (t a)
</span><a href="../../base/src/Data.Traversable.html#sequence"><span class="hs-identifier hs-var">sequence</span></a></span><span>
</span><span id="line-205"></span><span>
</span><span id="line-206"></span><span id="%24%24"><span class="annot"><span class="annottext">$$ :: Doc -&gt; Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#%24%24"><span class="hs-operator hs-var hs-var">($$)</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc -&gt; Doc) -&gt; Doc -&gt; Doc -&gt; Doc
forall (m :: * -&gt; *) a1 a2 r.
Monad m =&gt;
(a1 -&gt; a2 -&gt; r) -&gt; m a1 -&gt; m a2 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM2"><span class="hs-identifier hs-var">liftM2</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#%24%24"><span class="hs-operator hs-var">(HPJ.$$)</span></a></span><span>
</span><span id="line-207"></span><span id="%24%2B%24"><span class="annot"><span class="annottext">$+$ :: Doc -&gt; Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#%24%2B%24"><span class="hs-operator hs-var hs-var">($+$)</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc -&gt; Doc) -&gt; Doc -&gt; Doc -&gt; Doc
forall (m :: * -&gt; *) a1 a2 r.
Monad m =&gt;
(a1 -&gt; a2 -&gt; r) -&gt; m a1 -&gt; m a2 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM2"><span class="hs-identifier hs-var">liftM2</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#%24%2B%24"><span class="hs-operator hs-var">(HPJ.$+$)</span></a></span><span>
</span><span id="line-208"></span><span id="vcat"><span class="annot"><span class="annottext">vcat :: [Doc] -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#vcat"><span class="hs-identifier hs-var hs-var">vcat</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([Doc] -&gt; Doc) -&gt; PprM [Doc] -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#vcat"><span class="hs-identifier hs-var">HPJ.vcat</span></a></span><span> </span><span class="annot"><span class="annottext">(PprM [Doc] -&gt; Doc) -&gt; ([Doc] -&gt; PprM [Doc]) -&gt; [Doc] -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; PprM [Doc]
forall (t :: * -&gt; *) (m :: * -&gt; *) a.
(Traversable t, Monad m) =&gt;
t (m a) -&gt; m (t a)
</span><a href="../../base/src/Data.Traversable.html#sequence"><span class="hs-identifier hs-var">sequence</span></a></span><span>
</span><span id="line-209"></span><span>
</span><span id="line-210"></span><span id="cat"><span class="annot"><span class="annottext">cat :: [Doc] -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#cat"><span class="hs-identifier hs-var hs-var">cat</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([Doc] -&gt; Doc) -&gt; PprM [Doc] -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#cat"><span class="hs-identifier hs-var">HPJ.cat</span></a></span><span> </span><span class="annot"><span class="annottext">(PprM [Doc] -&gt; Doc) -&gt; ([Doc] -&gt; PprM [Doc]) -&gt; [Doc] -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; PprM [Doc]
forall (t :: * -&gt; *) (m :: * -&gt; *) a.
(Traversable t, Monad m) =&gt;
t (m a) -&gt; m (t a)
</span><a href="../../base/src/Data.Traversable.html#sequence"><span class="hs-identifier hs-var">sequence</span></a></span><span>
</span><span id="line-211"></span><span id="sep"><span class="annot"><span class="annottext">sep :: [Doc] -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#sep"><span class="hs-identifier hs-var hs-var">sep</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([Doc] -&gt; Doc) -&gt; PprM [Doc] -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#sep"><span class="hs-identifier hs-var">HPJ.sep</span></a></span><span> </span><span class="annot"><span class="annottext">(PprM [Doc] -&gt; Doc) -&gt; ([Doc] -&gt; PprM [Doc]) -&gt; [Doc] -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; PprM [Doc]
forall (t :: * -&gt; *) (m :: * -&gt; *) a.
(Traversable t, Monad m) =&gt;
t (m a) -&gt; m (t a)
</span><a href="../../base/src/Data.Traversable.html#sequence"><span class="hs-identifier hs-var">sequence</span></a></span><span>
</span><span id="line-212"></span><span id="fcat"><span class="annot"><span class="annottext">fcat :: [Doc] -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#fcat"><span class="hs-identifier hs-var hs-var">fcat</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([Doc] -&gt; Doc) -&gt; PprM [Doc] -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#fcat"><span class="hs-identifier hs-var">HPJ.fcat</span></a></span><span> </span><span class="annot"><span class="annottext">(PprM [Doc] -&gt; Doc) -&gt; ([Doc] -&gt; PprM [Doc]) -&gt; [Doc] -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; PprM [Doc]
forall (t :: * -&gt; *) (m :: * -&gt; *) a.
(Traversable t, Monad m) =&gt;
t (m a) -&gt; m (t a)
</span><a href="../../base/src/Data.Traversable.html#sequence"><span class="hs-identifier hs-var">sequence</span></a></span><span>
</span><span id="line-213"></span><span id="fsep"><span class="annot"><span class="annottext">fsep :: [Doc] -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#fsep"><span class="hs-identifier hs-var hs-var">fsep</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">([Doc] -&gt; Doc) -&gt; PprM [Doc] -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#fsep"><span class="hs-identifier hs-var">HPJ.fsep</span></a></span><span> </span><span class="annot"><span class="annottext">(PprM [Doc] -&gt; Doc) -&gt; ([Doc] -&gt; PprM [Doc]) -&gt; [Doc] -&gt; Doc
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="../../base/src/GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc] -&gt; PprM [Doc]
forall (t :: * -&gt; *) (m :: * -&gt; *) a.
(Traversable t, Monad m) =&gt;
t (m a) -&gt; m (t a)
</span><a href="../../base/src/Data.Traversable.html#sequence"><span class="hs-identifier hs-var">sequence</span></a></span><span>
</span><span id="line-214"></span><span>
</span><span id="line-215"></span><span id="nest"><span class="annot"><span class="annottext">nest :: Int -&gt; Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#nest"><span class="hs-identifier hs-var hs-var">nest</span></a></span></span><span> </span><span id="local-6989586621679163071"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679163071"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Doc -&gt; Doc) -&gt; Doc -&gt; Doc
forall (m :: * -&gt; *) a1 r. Monad m =&gt; (a1 -&gt; r) -&gt; m a1 -&gt; m r
</span><a href="../../base/src/GHC.Base.html#liftM"><span class="hs-identifier hs-var">liftM</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Doc -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#nest"><span class="hs-identifier hs-var">HPJ.nest</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679163071"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-216"></span><span>
</span><span id="line-217"></span><span id="hang"><span class="annot"><span class="annottext">hang :: Doc -&gt; Int -&gt; Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#hang"><span class="hs-identifier hs-var hs-var">hang</span></a></span></span><span> </span><span id="local-6989586621679163069"><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163069"><span class="hs-identifier hs-var">d1</span></a></span></span><span> </span><span id="local-6989586621679163068"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679163068"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span id="local-6989586621679163067"><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163067"><span class="hs-identifier hs-var">d2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679163066"><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163066"><span class="hs-identifier hs-var">d1'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163069"><span class="hs-identifier hs-var">d1</span></a></span><span>
</span><span id="line-218"></span><span>                  </span><span id="local-6989586621679163065"><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163065"><span class="hs-identifier hs-var">d2'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163067"><span class="hs-identifier hs-var">d2</span></a></span><span>
</span><span id="line-219"></span><span>                  </span><span class="annot"><span class="annottext">Doc -&gt; Doc
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Doc -&gt; Int -&gt; Doc -&gt; Doc
</span><a href="../../pretty/src/Text.PrettyPrint.HughesPJ.html#hang"><span class="hs-identifier hs-var">HPJ.hang</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163066"><span class="hs-identifier hs-var">d1'</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679163068"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163065"><span class="hs-identifier hs-var">d2'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-220"></span><span>
</span><span id="line-221"></span><span class="hs-comment">-- punctuate uses the same definition as Text.PrettyPrint</span><span>
</span><span id="line-222"></span><span id="punctuate"><span class="annot"><span class="annottext">punctuate :: Doc -&gt; [Doc] -&gt; [Doc]
</span><a href="Language.Haskell.TH.PprLib.html#punctuate"><span class="hs-identifier hs-var hs-var">punctuate</span></a></span></span><span> </span><span class="annot"><span class="annottext">Doc
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-223"></span><span class="annot"><a href="Language.Haskell.TH.PprLib.html#punctuate"><span class="hs-identifier hs-var">punctuate</span></a></span><span> </span><span id="local-6989586621679163063"><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163063"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679163062"><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163062"><span class="hs-identifier hs-var">d</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679163061"><span class="annot"><span class="annottext">[Doc]
</span><a href="#local-6989586621679163061"><span class="hs-identifier hs-var">ds</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; [Doc] -&gt; [Doc]
</span><a href="#local-6989586621679163060"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163062"><span class="hs-identifier hs-var">d</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc]
</span><a href="#local-6989586621679163061"><span class="hs-identifier hs-var">ds</span></a></span><span>
</span><span id="line-224"></span><span>                   </span><span class="hs-keyword">where</span><span>
</span><span id="line-225"></span><span>                     </span><span id="local-6989586621679163060"><span class="annot"><span class="annottext">go :: Doc -&gt; [Doc] -&gt; [Doc]
</span><a href="#local-6989586621679163060"><span class="hs-identifier hs-var hs-var">go</span></a></span></span><span> </span><span id="local-6989586621679163059"><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163059"><span class="hs-identifier hs-var">d'</span></a></span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163059"><span class="hs-identifier hs-var">d'</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-226"></span><span>                     </span><span class="annot"><a href="#local-6989586621679163060"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span id="local-6989586621679163058"><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163058"><span class="hs-identifier hs-var">d'</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679163057"><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163057"><span class="hs-identifier hs-var">e</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679163056"><span class="annot"><span class="annottext">[Doc]
</span><a href="#local-6989586621679163056"><span class="hs-identifier hs-var">es</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163058"><span class="hs-identifier hs-var">d'</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; Doc -&gt; Doc
</span><a href="Language.Haskell.TH.PprLib.html#%3C%3E"><span class="hs-operator hs-var">&lt;&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163063"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Doc -&gt; [Doc] -&gt; [Doc]
forall a. a -&gt; [a] -&gt; [a]
</span><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-var">:</span></a></span><span> </span><span class="annot"><span class="annottext">Doc -&gt; [Doc] -&gt; [Doc]
</span><a href="#local-6989586621679163060"><span class="hs-identifier hs-var">go</span></a></span><span> </span><span class="annot"><span class="annottext">Doc
</span><a href="#local-6989586621679163057"><span class="hs-identifier hs-var">e</span></a></span><span> </span><span class="annot"><span class="annottext">[Doc]
</span><a href="#local-6989586621679163056"><span class="hs-identifier hs-var">es</span></a></span><span>
</span><span id="line-227"></span></pre></body></html>